package cn.hr.dao;

import java.io.*;  
import java.sql.SQLException;
import java.util.*;
import org.hibernate.*;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.ProjectionList;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.*;
import org.springframework.orm.hibernate3.support.*;

/**
 * 通用DAO的Hibernate实现
 * 
 * @author 吴坚洪
 * 
 */

public class CommonDao extends HibernateDaoSupport {

	/**
	 * 保存（持久化）一个对象
	 * 
	 * @param object
	 *            要保存的对象
	 */
	public Serializable save(Object object) {
		return getHibernateTemplate().save(object);
	}

	/**
	 * 更新一个对象
	 * 
	 * @param object
	 *            要修改的对象
	 */
	public void update(Object object) {
		getHibernateTemplate().update(object);
	}

	/**
	 * 用语句更新记录
	 * 
	 * @param queryString
	 *            查询语句
	 * @param parameters
	 *            参数
	 */
	public void updateByQuery(final String queryString, final Object... objects) {
		getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createQuery(queryString);
				if (objects != null) {
					for (int i = 0; i < objects.length; i++) {
						query.setParameter(i, objects[i]);
					}
				}
				query.executeUpdate();
				return null;
			}
		});
	}

	/**
	 * 删除一个对象
	 * 
	 * @param object
	 *            要删除的对象
	 */
	public void delete(Object object) {
		getHibernateTemplate().delete(object);
	}

	/**
	 * 根据类型和对象id删除一个对象
	 * 
	 * @param clazz
	 *            类型
	 * @param id
	 *            对象id
	 */
	public void delete(Class clazz, Serializable id) {
		getHibernateTemplate().delete(load(clazz, id));
	}

	/**
	 * 根据类型删除全部对象
	 * 
	 * @param clazz
	 *            类型
	 * @return Integer
	 */
	public Integer deleteAll(final Class clazz) {
		return (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session) {
						Query query = session.createQuery("delete "
								+ clazz.getName());
						return new Integer(query.executeUpdate());
					}
				});
	}


	
	/**
	 * 获取session
	 * 
	 * @param null
	 *          
	 * @param 
	 * @return session
	 */
	
	public Session getFactorySession(){
		
		return this.getSession();
	}


	/**
	 * 根据类型和对象id载入一个对象
	 * 
	 * @param clazz
	 *            类型
	 * @param id
	 *            对象id
	 * @return 目标对象
	 */
	public Object load(Class clazz, Serializable id) {
		return getHibernateTemplate().load(clazz, id);
	}

	/**
	 * 根据类型和对象id从数据库取得一个对象
	 * 
	 * @param clazz
	 *            类
	 * @param id
	 *            对象id
	 * @return 目标对象
	 */
	public Object get(Class clazz, Serializable id) {
		return this.getSession().get(clazz, id);
	}

	/**
	 * 命名查询
	 * 
	 * @param queryName
	 *            命名查询语句
	 * @return 对象列表
	 */
	public List findByNamedQuery(final String queryName) {
		return getHibernateTemplate().findByNamedQuery(queryName);
	}

	/**
	 * 依据单个参数做命名查询
	 * 
	 * @param query
	 *            命名查询语句
	 * @param parameter
	 *            单个查询参数
	 * @return 对象列表
	 */
	public List findByNamedQuery(final String queryName, final Object parameter) {
		return getHibernateTemplate().findByNamedQuery(queryName, parameter);
	}

	/**
	 * 依据参数数组做命名查询
	 * 
	 * @param query
	 *            命名查询语句
	 * @param parameters
	 *            查询参数数组
	 * @return 对象列表
	 */
	public List findByNamedQuery(final String queryName,
			final Object... objects) {
		return getHibernateTemplate().findByNamedQuery(queryName, objects);
	}

	/**
	 * 查询全部
	 * 
	 * @param query
	 *            查询语句
	 * @return 对象列表
	 */
	public List find(final String queryString) {
		return getHibernateTemplate().find(queryString);
	}

	/**
	 * 带参数查询全部
	 * 
	 * @param queryString
	 *            查询语句
	 * @param parameters
	 *            查询参数
	 * @return 对象列表
	 */
	public List find(final String queryString, final Object... objects) {
		return getHibernateTemplate().find(queryString, objects);
	}

	/**
	 * 根据查询和参数删除全部对象
	 * 
	 * @param queryString
	 *            查询语句
	 * @param parameters
	 *            参数
	 * @return Integer
	 */
	public Integer deleteByQuery(final String queryString,
			final Object... objects) {
		return (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session) {
						Query query = session.createQuery(queryString);
						if (objects != null) {
							for (int i = 0; i < objects.length; i++) {
								query.setParameter(i, objects[i]);
							}
						}
				
						return new Integer(query.executeUpdate());
						
					}
				});
	}

	/**
	 * 根据查询语句和查询参数从数据库取得一个对象
	 * 
	 * @param queryString
	 *            查询语句
	 * @param parameters
	 *            参数
	 * @return Object 单个对象
	 */
	public Object get(final String queryString, final Object... objects) {
		List list = getHibernateTemplate().find(queryString, objects);
		if (list != null && !list.isEmpty()) {
			return list.get(0);
		}
		return null;
	}

	/**
	 * Description 获得某个对象的全部总数
	 * 
	 * @param 对象Class
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public int count(Class clazz) {
		String queryString = "SELECT COUNT(*) FROM " + clazz.getName();
		List list = getHibernateTemplate().find(queryString);
		return Integer.parseInt(list.get(0).toString());
	}
	
	/**
	 * Description 获得某个对象的全部总数
	 * 
	 * @param 查询语句
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public int count(String queryString) {
		if(queryString.indexOf("select")<0){
			queryString="SELECT COUNT(*) "+queryString;
		}
		List list = getHibernateTemplate().find(queryString);
		return Integer.parseInt(list.get(0).toString());
	}
	
	/**
	 * Description 获得某个对象的全部总数
	 * 
	 * @param 查询语句
	 * @param 参数
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public int count(String queryString, final Object... objects) {
		if(queryString.indexOf("select")<0){
			queryString="SELECT COUNT(*) "+queryString;
		}
		List list = getHibernateTemplate().find(queryString, objects);
		return Integer.parseInt(list.get(0).toString());
	}
	/**
	 * Description 根据参数获得某个对象的全部总数
	 * 
	 * @param 对象Class
	 * @param 参数名
	 * @param 参数值
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public int count(Class clazz, String propertyName, Object propertyValue) {
		String realValue = "";
		if (true == propertyValue instanceof String) {
			realValue = "'" + propertyValue + "'";
		} else {
			realValue = propertyValue.toString();
		}

		String queryString = "SELECT COUNT(*) FROM " + clazz.getName()
				+ " o WHERE o." + propertyName + " = " + realValue;
		List list = getHibernateTemplate().find(queryString);
		return Integer.parseInt(list.get(0).toString());
	}

	/**
	 * Description 根据约束条件获得某个对象的全部总数
	 * 
	 * @param 对象Class
	 * @param 约束条件
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public int count(final Class clazz, final Criterion[] criterions) {
		Integer count = (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria criteria = session.createCriteria(clazz);
						// 循环遍历添加约束条件
						for (int i = 0; i < criterions.length; i++) {
							criteria.add(criterions[i]);
						}

						return criteria.setProjection(Projections.rowCount())
								.uniqueResult();
					}
				});

		return count;
	}

	/**
	 * Description 获得某个类型的全部对象列表
	 * 
	 * @param 对象Class
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final Class clazz) {
		return this.find("from " + clazz.getName());
	}

	/** 
	 * Description 根据约束条件获得某个对象的全部对象列表
	 * @param 查询语句
	 * @param 约束条件
	 * @return 
	 * @Author  徐华聪	
	 * @Create Date 2009-5-19 
	 */ 
	public List find(final String queryString, final Criterion[] criterions) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(queryString);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				return criteria.list();
			}
		});
		return list;
	}

	/** 
	 * Description 根据约束条件获得某个对象的全部对象列表
	 * @param 对象Class
	 * @param 约束条件
	 * @return 
	 * @Author  徐华聪	
	 * @Create Date 2009-5-19 
	 */ 
	public List find(final Class clazz, final Criterion[] criterions) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(clazz);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				return criteria.list();
			}
		});
		return list;
	}
	/** 
	 * Description  根据约束条件获得某个对象的全部对象排序列表  	
	 * @param 查询语句
	 * @param 约束条件
	 * @param 排序条件
	 * @return 
	 * @Author  徐华聪	
	 * @Create Date 2009-5-19 
	 */ 
	public List find(final String queryString, final Criterion[] criterions,
			final Order[] orders) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(queryString);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				for (int i = 0; i < orders.length; i++) {
					criteria.addOrder(orders[i]);
				}
				return criteria.list();
			}
		});
		return list;
	}
	/** 
	 * Description  根据约束条件获得某个对象的全部对象排序列表  	
	 * @param 对象Class
	 * @param 约束条件
	 * @param 排序条件
	 * @return 
	 * @Author  徐华聪	
	 * @Create Date 2009-5-19 
	 */ 
	public List find(final Class clazz, final Criterion[] criterions,
			final Order[] orders) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(clazz);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				for (int i = 0; i < orders.length; i++) {
					criteria.addOrder(orders[i]);
				}
				return criteria.list();
			}
		});
		return list;
	}

	/**
	 * Description 分页查询
	 * 
	 * @param 查询语句
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final String queryString, final int page, final int size) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createQuery(queryString);
				query.setFirstResult(page * size);
				query.setMaxResults(size);
				List list = query.list();
				return list;
			}
		});
		return list;
	}
	/**
	 * Description 分页查询
	 * 
	 * @param 对象Class
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final Class clazz, final int page, final int size) {
		return this.find("from " + clazz.getName(), page, size);
	}

	/**
	 * Description 根据参数分页查询
	 * 
	 * @param 查询语句
	 * @param 参数名
	 * @param 参数值
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final String queryString, final String[] propertyName,
			final Object[] propertyValue, final int page, final int size) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createQuery(queryString);
				for (int i = 0; i < propertyName.length; i++) {
					query.setParameter(propertyName[i], propertyValue[i]);
				}
				query.setFirstResult(page * size);
				query.setMaxResults(size);
				List list = query.list();
				return list;
			}
		});
		return list;
	}
	/**
	 * Description 根据参数分页查询
	 * 
	 * @param 查询语句
	 * @param 对象Class
	 * @param 参数值
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final Class clazz, final String[] propertyName,
			final Object[] propertyValue, final int page, final int size) {
		return this.find("from " + clazz.getName(),propertyName,propertyName, page, size);
	}

	/**
	 * Description 根据约束条件分页查询
	 * 
	 * @param 查询语句
	 * @param 约束条件
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final String queryString, final Criterion[] criterions,
			final int page, final int size) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(queryString);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				criteria.setFirstResult(page * size);
				criteria.setMaxResults(size);
				return criteria.list();
			}
		});
		return list;
	}

	/**
	 * Description 根据约束条件分页查询
	 * 
	 * @param 查询语句
	 * @param 约束条件
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final String queryString,
			final int page, final int size,final Object... objects) {
		
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createQuery(queryString);
				for (int i = 0; i < objects.length; i++) {
					query.setParameter(i, objects[i]);
				}
				query.setFirstResult(page * size);
				query.setMaxResults(size); 
				List list = query.list();
				return list;
			}
		});
		return list;
	}
	

	/**
	 * Description 根据约束条件分页查询
	 * 
	 * @param 对象Class
	 * @param 约束条件
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final Class clazz, final Criterion[] criterions,
			final int page, final int size) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(clazz);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				criteria.setFirstResult(page * size);
				criteria.setMaxResults(size);
				return criteria.list();
			}
		});
		return list;
	}
	/**
	 * Description 根据约束条件分页排序查询
	 * 
	 * @param 查询语句
	 * @param 约束条件
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final String queryString, final Criterion[] criterions,
			final Order[] orders,	final int page, final int size) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(queryString);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				for (int i = 0; i < orders.length; i++) {
					criteria.addOrder(orders[i]);
				}
				criteria.setFirstResult(page * size);
				criteria.setMaxResults(size);
				return criteria.list();
			}
		});
		return list;
	}
	/**
	 * Description 根据约束条件分页排序查询
	 * 
	 * @param 对象Class
	 * @param 约束条件
	 * @param 页码
	 * @param 页容量
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public List find(final Class clazz, final Criterion[] criterions,
			final Order[] orders,	final int page, final int size) {
		List list = getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria criteria = session.createCriteria(clazz);
				// 循环遍历添加约束条件
				for (int i = 0; i < criterions.length; i++) {
					criteria.add(criterions[i]);
				}
				for (int i = 0; i < orders.length; i++) {
					criteria.addOrder(orders[i]);
				}
				criteria.setFirstResult(page * size);
				criteria.setMaxResults(size);
				return criteria.list();
			}
		});
		return list;
	}
	/**
	 * Description 根据投影与约束条件获得某些数据
	 * 
	 * @param 对象Class
	 * @param 投影
	 * @param 约束条件
	 * @return
	 * @Author 徐华聪
	 * @Create Date 2009-5-18
	 */
	public Object getProjectionBean(final Class clazz, final ProjectionList prolist,final Criterion[] criterions) {
		Object object = (Object) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria criteria = session.createCriteria(clazz);
						// 循环遍历添加约束条件
						if(criterions!=null){
						for (int i = 0; i < criterions.length; i++) {
							criteria.add(criterions[i]);
						}
						}
						return criteria.setProjection(prolist)
								.uniqueResult();
					}
				});

		return object;
	}

	// 徐华聪: Criterion、Order创建说明
	// Criterion [] criterions={Restrictions.eq("state", 1)};
	// Order [] order={Order.desc("ID")};
}
